package ;

import flixel.FlxG;
import flixel.FlxSprite;
import flixel.util.FlxColor;
import flixel.util.FlxTimer;
import flixel.effects.particles.FlxEmitter;
import Math;

/**
 * ...
 * @author Ignacio
 */
 
class Bloques extends FlxSprite    //Basicamente un bloque es un objeto al cual ni la luz ni el jugador pueden atravesar, pueden ser Dinamicos o Estaticos
{

//--------------Para Bloques Tipo Receptor------------

	public var _indicador:FlxSprite;

//--------------Para Bloques Tipo Rompibles------------

	public var _vida:Int = Reg._vidaBloque;

//--------------Para Bloques Tipo Emisor------------

	public var _emitter:FlxEmitter;
			 
	private var _foton:Fotones;
	 
	private var _velocidadLaser:Int = 700;
	 
//---------------------Para Todos-------------------	

	public var _velocidadAngular: Float = (Math.PI / (2  * FlxG.updateFramerate * Reg._tiempoGiro));

	public var _angulo:Float = 0; //Arg1 (En Radianes)

	public var _direccion:Int = 0; //Arg1
	
	public var _color:Int = 0;   //Arg2
	
	public var _timerGiroT:FlxTimer;
	
	public var _timerGirot:FlxTimer;
	
	public var _giro:Bool = false;
	
	public var _girando:Bool = false;
	
	public var _esDinamico:Bool;
	
	public var _seguir:Bool;
	
	public var _altoB:Int = 60;
	
	public var _tipo:String;  //Los tipos de Bloques son: "Emisor", "Receptor", "Pared", "Bloques" ...

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

	public function new(X:Int, Y:Int, Dinamico:Bool, Tipo:String, Arg1:Int, Arg2:Int)
	{
		super(X, Y);
	
//------Para todos los Bloques------------------------------------------------------
		{
		//--Para los Bloques que giran discreto como los Receptores---
		_direccion = Arg1;
		
		//--Asignaciones-------
		_esDinamico = Dinamico;
		_tipo = Tipo;
		
		//--Variables Iniciales-----------
		elasticity = 0;
		
		immovable = true;
		
		_timerGirot =  new FlxTimer(5,giro);

		_timerGiroT =  new FlxTimer(5,girando);
		}

//------Especial para cada tipo de Bloque--------------------------------------------

		//------Esto solo si el bloque es una Pared------------------------
		if (Tipo == "Pared")
		{
			loadGraphic("assets/images/ParedV1.0_60x60_1Frame.png", false, 60, 60);
		}
				
		//------Esto solo si el bloque es uno Rompible------------------------
		if (Tipo == "Rompible")
		{
			loadGraphic("assets/images/RompibleV1.0_60x60_1Frame.png", false, 60, 60);
		}		

		//------Esto solo si el bloque es Emisor------------------------
		if (Tipo == "Emisor")
		{
			_angulo = Arg1;
			_color = Arg2;
			
			_emitter = new FlxEmitter(this.x, this.y, 0);
	 
			loadGraphic("assets/images/EmisorLaserV1.0_60x60_2Frames.png", true,60,60);

			animation.add("Emitir", [0, 1, 0, 1], 30, true);
			
			for (i in 0 ... 200)
			{
				var _foton = new Fotones(_color);
				_foton.visible = false;
				_emitter.add(_foton);
			}
			
			_emitter.start(false, 2, 0.05);
			
		}
		
		
		//------Esto solo si el bloque es Receptor------------------------
		if (Tipo == "Receptor")
		{
			_angulo = Arg1;
			_color = Arg2;
			
			loadGraphic("assets/images/ReceptorLaserV1.0_60x60_2Frames.png", true,60,60);
			
			animation.add("Receptar", [0, 1, 0, 1], 30, true);
			
			_indicador = new FlxSprite(this.x, this.y);
				
			_indicador.mass = Arg2;
			
			if (_color == 1)
			{
				_indicador.makeGraphic(20, 20, FlxColor.BLUE);
			}
			if (_color == 2)
			{
				_indicador.makeGraphic(20, 20,FlxColor.GREEN);
			}
			if (_color == 3)
			{
				_indicador.makeGraphic(20, 20,FlxColor.HOT_PINK);
			}
			if (_color == 4)
			{
				_indicador.makeGraphic(20, 20,FlxColor.YELLOW);
			}
			if (_color == 5)
			{
				_indicador.makeGraphic(20, 20,FlxColor.CORAL);
			}
			if (_color == 6)
			{
				_indicador.makeGraphic(20, 20,FlxColor.BLACK);
			}
			if (_color == 7)
			{
				_indicador.makeGraphic(20, 20,FlxColor.WHITE);
			}
			if (_color == 8)
			{
				_indicador.makeGraphic(20, 20,FlxColor.PURPLE);
			}
			if (_color == 9)
			{
				_indicador.makeGraphic(20, 20,FlxColor.RED);
			}
			
			_indicador.immovable = true;
		}
		
		//---Todo lo que tine que ver el ajuste de los graficos de los Bloques---
		set_width(Reg._altoB);
		set_height(Reg._altoB);
		setGraphicSize(Reg._altoB, Reg._altoB);
		setSize(Reg._altoB, Reg._altoB);
		updateHitbox();
	}


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------	
	
	override public function update():Void
	{
		super.update();
		
//Ajustes que se hacen para no sobrepasarse en los angulos o direcciones al dar la vuelta completa---
		{
		if (_angulo >= 2 * Math.PI)
		{
			_angulo = 0;
		}
		if (_angulo <= -2 * Math.PI)
		{
			_angulo = 0;
		}
		
		if (_direccion > 3)
		{
			_direccion = 0;
		}
		if (_direccion < 0)
		{
			_direccion = 3;
		}
		}
//-----Todo este If se encarga de que el laser ya sea que esta no esta girando o que se agarra mientras esta girando quede un angulo multiplo entero de Pi/2
		
		if ((_girando && Reg._grab) || !_giro || !_girando)
		{
			if (0 <= _angulo && _angulo < Math.PI / 2)
			{
				_angulo = 0;
			}
			
			if(-2 * Math.PI < _angulo && _angulo <= -1 * Math.PI * (3 / 2))
			{
				_angulo = -1 * Math.PI * (3/ 2);
			}
			
			if (Math.PI / 2 <= _angulo && _angulo < Math.PI) 
			{
				_angulo =  Math.PI / 2;
			}
			
			if(-1 * Math.PI * (3 / 2) < _angulo && _angulo <= -1 * Math.PI)
			{
				_angulo = -1 * Math.PI; 
			}
			
			if(Math.PI <= _angulo && _angulo < Math.PI * (3 / 2))
			{
				_angulo =  Math.PI;
			}
			
			if( -1 * Math.PI < _angulo && _angulo <= -1 * Math.PI / 2)
			{
				_angulo = -1 * Math.PI / 2;
			}
			
			if(Math.PI * (3 / 2) <= _angulo && _angulo < 2 * Math.PI)
			{
				_angulo = Math.PI * (3 / 2);
			}
			
			if( -1 * Math.PI / 2 < _angulo && _angulo <= 0)
			{
				_angulo = 0;
			}
		}
	
		if (_tipo == "Emisor") //El emisor tiene que saber si cambio de direccion en una plataforma Giratoria, o en el Editor
		{
			_emitter.setPosition(this.x + (_altoB) / 2, this.y + (_altoB) / 2);
			
			_emitter.setXSpeed(_velocidadLaser * Math.cos(_angulo) , _velocidadLaser * Math.cos(_angulo) + 0.001);
			_emitter.setYSpeed(_velocidadLaser * Math.sin(_angulo), _velocidadLaser * Math.sin(_angulo) + 0.001);
			
		}
		
		if (_tipo == "Receptor") //El receptor tiene que saber si cambio de direccion en el editor
		{
			if (_direccion == 0)
			{
				_indicador.setPosition(this.x + _altoB - 10 , this.y + _altoB / 2 - 10);
			}
			
			if (_direccion == 1)
			{
				_indicador.setPosition(this.x + _altoB / 2 - 10 , this.y - 10);
			}
			
			if (_direccion == 2)
			{
				_indicador.setPosition(this.x - 10 , this.y + _altoB / 2 - 10);
			}
			
			if (_direccion == 3)
			{
				_indicador.setPosition(this.x + _altoB / 2 - 10, this.y + _altoB - 10);
			}
		}
		
		if (_tipo == "Rompible") //El Bloque Rompible tiene que saber como esta su vida
		{
			if (_vida <= 0)
			{
				exists = false;
			}
			
			if (_vida < Reg._vidaBloque / 4)
			{
				color = 0x33333FF;
			}
			
			if (_vida >= Reg._vidaBloque / 4 && _vida < Reg._vidaBloque / 2)
			{
				color = 0x7777FF;
			}
			
			if (_vida >= Reg._vidaBloque / 2 && _vida < Reg._vidaBloque * (3/4))
			{
				color = 0xBBBBFF;
			}
			
			if (_vida >= Reg._vidaBloque * (3/4))
			{
				color = 0xFFFFFF;
			}
		}
	}	

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

	public function giro(time:FlxTimer):Void //Solo es una funcion que setea _giro en false, asi cada 'T' segundos del Timer pueda girar la plataforma (Ademas estabiliza el giro para que no quede en un angulo que no sea recto)
	{
		_giro = false;
		
		if (0 <= _angulo && _angulo < Math.PI / 2)
		{
			_angulo = 0;
		}
		
		if(-2 * Math.PI < _angulo && _angulo <= -1 * Math.PI * (3 / 2))
		{
			_angulo = -1 * Math.PI * (3/ 2);
		}
		
		if (Math.PI / 2 <= _angulo && _angulo < Math.PI) 
		{
			_angulo =  Math.PI / 2;
		}
		
		if(-1 * Math.PI * (3 / 2) < _angulo && _angulo <= -1 * Math.PI)
		{
			_angulo = -1 * Math.PI; 
		}
		
		if(Math.PI <= _angulo && _angulo < Math.PI * (3 / 2))
		{
			_angulo =  Math.PI;
		}
		
		if( -1 * Math.PI < _angulo && _angulo <= -1 * Math.PI / 2)
		{
			_angulo = -1 * Math.PI / 2;
		}
		
		if(Math.PI * (3 / 2) <= _angulo && _angulo < 2 * Math.PI)
		{
			_angulo = Math.PI * (3 / 2);
		}
		
		if( -1 * Math.PI / 2 < _angulo && _angulo <= 0)
		{
			_angulo = 0;
		}
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
	
	public function girando(time:FlxTimer):Void //Solo es una funcion que setea _girando en false, asi tiene 't' segundos para girar la plataforma
	{
		_girando = false;
		
	}
	
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

}